home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / Main.bin / ObjectOutputStream.java < prev    next >
Text File  |  1998-09-22  |  45KB  |  1,343 lines
  1. /*
  2.  * @(#)ObjectOutputStream.java    1.36 98/07/01
  3.  *
  4.  * Copyright 1995-1998 by Sun Microsystems, Inc.,
  5.  * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
  6.  * All rights reserved.
  7.  * 
  8.  * This software is the confidential and proprietary information
  9.  * of Sun Microsystems, Inc. ("Confidential Information").  You
  10.  * shall not disclose such Confidential Information and shall use
  11.  * it only in accordance with the terms of the license agreement
  12.  * you entered into with Sun.
  13.  */
  14.  
  15. package java.io;
  16.  
  17. import java.util.Stack;
  18.  
  19. import sun.io.ObjectOutputStreamDelegate; // RMI over IIOP hook.
  20.  
  21. /**
  22.  * An ObjectOutputStream writes primitive data types and graphs of
  23.  * Java objects to an OutputStream.  The objects can be read
  24.  * (reconstituted) using an ObjectInputStream.
  25.  * Persistent storage of objects can be accomplished by using a file for
  26.  * the stream.
  27.  * If the stream is a network socket stream, the objects can be reconsituted
  28.  * on another host or in another process. <p>
  29.  *
  30.  * Only objects that support the java.io.Serializable interface can be
  31.  * written to streams.
  32.  *
  33.  * The class of each serializable object is encoded including the class
  34.  * name and signature of the class, the values of the
  35.  * object's fields and arrays, and the closure of any other objects
  36.  * referenced from the initial objects. <p>
  37.  * 
  38.  * The method <STRONG>writeObject</STRONG> is used to write an object
  39.  * to the stream.  Any object, including Strings and arrays, is
  40.  * written with writeObject. Multiple objects or primitives can be
  41.  * written to the stream.  The objects must be read back from the
  42.  * corresponding ObjectInputstream with the same types and in the same
  43.  * order as they were written.<p>
  44.  *
  45.  * Primitive data types can also be written to the stream using the
  46.  * appropriate methods from DataOutput. Strings can also be written
  47.  * using the writeUTF method.<p>
  48.  *
  49.  * The default serialization mechanism for an object writes the class
  50.  * of the object, the class signature, and the values of all
  51.  * non-transient and non-static fields.  References to other objects
  52.  * (except in transient or static fields) cause those objects to be
  53.  * written also. Multiple references to a single object are encoded
  54.  * using a reference sharing mechanism so that graphs of objects can
  55.  * be restored to the same shape as when the original was written. <p>
  56.  *
  57.  * For example to write an object that can be read by the example in ObjectInputStream: <br>
  58.  * <PRE>
  59.  *    FileOutputStream ostream = new FileOutputStream("t.tmp");
  60.  *    ObjectOutputStream p = new ObjectOutputStream(ostream);
  61.  *
  62.  *    p.writeInt(12345);
  63.  *    p.writeObject("Today");
  64.  *    p.writeObject(new Date());
  65.  *
  66.  *    p.flush();
  67.  *    ostream.close();
  68.  *
  69.  * </PRE>
  70.  *
  71.  * Classes that require special handling during the serialization and deserialization
  72.  * process must implement special methods with these exact signatures: <p>
  73.  *
  74.  * <PRE>
  75.  * private void readObject(java.io.ObjectInputStream stream)
  76.  *     throws IOException, ClassNotFoundException; 
  77.  * private void writeObject(java.io.ObjectOutputStream stream)
  78.  *     throws IOException
  79.  * </PRE><p>
  80.  * The writeObject method is responsible for writing the state of
  81.  * the object for its particular class so that the corresponding
  82.  * readObject method can restore it.
  83.  * The method does not need to concern itself with the
  84.  * state belonging to the object's superclasses or subclasses.
  85.  * State is saved by writing the individual fields to the ObjectOutputStream
  86.  * using the writeObject method or by using the methods for
  87.  * primitive data types supported by DataOutput. <p>
  88.  *
  89.  * Serialization does not write out the fields of any object that does
  90.  * not implement the java.io.Serializable interface.  Subclasses of
  91.  * Objects that are not serializable can be serializable. In this case
  92.  * the non-serializable class must have a no-arg constructor to allow
  93.  * its fields to be initialized.  In this case it is the
  94.  * responsibility of the subclass to save and restore the state of the
  95.  * non-serializable class. It is frequently the case that the fields
  96.  * of that class are accessible (public, package, or protected) or
  97.  * that there are get and set methods that can be used to restore the
  98.  * state. <p>
  99.  *
  100.  * Serialization of an object can be prevented by implementing writeObject
  101.  * and readObject methods that throw the NotSerializableException.
  102.  * The exception will be caught by the ObjectOutputStream and abort the
  103.  * serialization process.
  104.  *
  105.  * Implementing the Externalizable interface allows the object to
  106.  * assume complete control over the contents and format of the object's
  107.  * serialized form.  The methods of the Externalizable interface,
  108.  * writeExternal and readExternal, are called to save and restore the
  109.  * objects state.  When implemented by a class they can write and read
  110.  * their own state using all of the methods of ObjectOutput and
  111.  * ObjectInput.  It is the responsibility of the objects to handle any
  112.  * versioning that occurs.
  113.  *
  114.  * @author    Roger Riggs
  115.  * @version     1.36, 07/01/98
  116.  * @see java.io.DataOutput
  117.  * @see java.io.ObjectInputStream
  118.  * @see java.io.Serializable
  119.  * @see java.io.Externalizable
  120.  * @since       JDK1.1
  121.  */
  122. public class ObjectOutputStream
  123.     extends OutputStream
  124.     implements ObjectOutput, ObjectStreamConstants
  125.             
  126. { 
  127.     /** 
  128.      * Creates an ObjectOutputStream that writes to the specified OutputStream.
  129.      * The stream header is written to the stream. The caller may want to call
  130.      * flush immediately so that the corresponding ObjectInputStream can read
  131.      * the header immediately.
  132.      * @exception IOException Any exception thrown by the underlying OutputStream.
  133.      * @since     JDK1.1
  134.      */
  135.     public ObjectOutputStream(OutputStream out) throws IOException {
  136.  
  137.         /*
  138.          * RMI over IIOP hook. Check if we are a trusted subclass
  139.          * that has implemented the "sun.io.ObjectOutputStream"
  140.          * interface. If so, set our private flag that will be
  141.          * checked in "writeObject", "defaultWriteObject" and
  142.          * "enableReplaceObject". Note that we don't initialize
  143.          * private instance variables in this case as an optimization
  144.          * (subclasses using the hook should have no need for them).
  145.          */
  146.         
  147.         if (this instanceof sun.io.ObjectOutputStreamDelegate && this.getClass().getClassLoader() == null) {
  148.             isTrustedSubclass = true;
  149.             return;
  150.         }
  151.         
  152.     this.out = out;
  153.     dos = new DataOutputStream(this);
  154.     buf = new byte[1024];    // allocate buffer
  155.     writeStreamHeader();
  156.     resetStream();
  157.     }
  158.  
  159.     /**
  160.      * Write the specified object to the ObjectOutputStream.
  161.      * The class of the object, the signature of the class, and the values
  162.      * of the non-transient and non-static fields of the class and all
  163.      * of its supertypes are written.  Default serialization for a class can be
  164.      * overridden using the writeObject and the readObject methods. 
  165.      * Objects referenced by this object are written transitively so
  166.      * that a complete equivalent graph of objects can be
  167.      * reconstructed by an ObjectInputStream.  <p>
  168.      *
  169.      * Exceptions are thrown for
  170.      * problems with the OutputStream and for classes that should not be
  171.      * serialized.  All exceptions are fatal to the OutputStream, which
  172.      * is left in an indeterminate state, and it is up to the caller
  173.      * to ignore or recover the stream state.
  174.      * @exception InvalidClassException Something is wrong with a class used by
  175.      *       serialization.
  176.      * @exception NotSerializableException Some object to be serialized does not
  177.      *      implement the java.io.Serializable interface.
  178.      * @exception IOException Any exception thrown by the underlying OutputStream.
  179.      * @since     JDK1.1
  180.      */
  181.     public final void writeObject(Object obj)
  182.     throws IOException
  183.     {
  184.      
  185.     /*
  186.      * RMI over IIOP hook. Invoke delegate method if indicated.
  187.      */
  188.     if (isTrustedSubclass) {
  189.         ((ObjectOutputStreamDelegate) this).writeObjectDelegate(obj);
  190.         return;
  191.     }
  192.  
  193.     Object prevObject = currentObject;
  194.     ObjectStreamClass prevClassDesc = currentClassDesc;
  195.     boolean oldBlockDataMode = setBlockData(false);
  196.     recursionDepth++;
  197.  
  198.     try {
  199.         if (serializeNullAndRepeat(obj))
  200.         return;
  201.  
  202.         if (checkSpecialClasses(obj))
  203.         return;
  204.  
  205.  
  206.         /* If the replacment is enabled, give subclasses one chance
  207.          * to substitute a new object. If one is substituted,
  208.          * recheck for null, repeated refs, and special cased classes
  209.          */
  210.         if (enableReplace) {
  211.         Object altobj = replaceObject(obj);
  212.         if (obj != altobj) {
  213.  
  214.             if (altobj != null && !(altobj instanceof Serializable)) {
  215.             String clname = altobj.getClass().getName();
  216.             throw new NotSerializableException(clname);
  217.             }
  218.             
  219.             // If the alternate object is already
  220.             // serialized just remember the replacement
  221.             if (serializeNullAndRepeat(altobj)) {
  222.             addReplacement(obj, altobj);
  223.             return;
  224.             }
  225.  
  226.             /* Add this to the set of replaced objects.
  227.              * This must be done before the object is
  228.              * serialized so that if the object indirectly
  229.              * refers to the original it will be redirected to
  230.              * the replacement.
  231.              *
  232.              * NB: checkSpecialClasses should only call
  233.              * serializeNullandRepeat for objects that will not
  234.              * recurse.
  235.              */
  236.             addReplacement(obj, altobj);
  237.  
  238.             if (checkSpecialClasses(altobj))
  239.             return;
  240.  
  241.             obj = altobj;
  242.         }
  243.         }
  244.         if (checkSubstitutableSpecialClasses(obj))
  245.         return;
  246.         else {
  247.         /* Write out the object as itself */
  248.         outputObject(obj);
  249.         }
  250.     } catch (ObjectStreamException ee) {
  251.         if (abortIOException == null) {
  252.         try {
  253.             /* Prepare to write the exception to the stream.
  254.              * End blockdatamode in case it's set
  255.              * Write the exception code
  256.              * reset the stream to forget all previous objects
  257.              * write the exception that occurred
  258.              * reset the stream again so subsequent objects won't map to
  259.              * the exception or its args.
  260.              * Continue below to rethrow the exception.
  261.              */
  262.             setBlockData(false);
  263.  
  264.             writeCode(TC_EXCEPTION);
  265.             resetStream();
  266.             this.writeObject(ee);
  267.             resetStream();
  268.  
  269.             // Set the pending exception to be rethrown.
  270.             abortIOException = ee;
  271.         } catch (IOException fatal) {
  272.             /* An exception occurred while writing the original exception to
  273.              * the stream.  The original exception is not complete in
  274.              * the stream and recusion would be bad. Supercede the original
  275.              * Exception with a StreamCorruptedException using the message
  276.              * from this current exception.
  277.              */
  278.             abortIOException =
  279.             new StreamCorruptedException(fatal.getMessage());
  280.         }
  281.         }
  282.     } catch (IOException ee) {
  283.         // Don't supercede a pending exception, the original will be re-thrown.
  284.         if (abortIOException == null)
  285.         abortIOException = ee;
  286.         
  287.     } finally {
  288.         /* Restore state of previous call incase this is a nested call */
  289.         recursionDepth--;
  290.         currentObject = prevObject;
  291.         currentClassDesc = prevClassDesc;
  292.         setBlockData(oldBlockDataMode);
  293.     }
  294.     
  295.     /* If the recursion depth is 0, test for and clear the pending exception.
  296.      * If there is a pending exception throw it.
  297.      */
  298.     IOException pending = abortIOException;
  299.     if (recursionDepth == 0)
  300.         abortIOException = null;
  301.     if (pending != null) {
  302.         throw pending;
  303.     }
  304.     }
  305.     
  306.     /*
  307.      * Check for special cases of serializing objects.
  308.      */
  309.     private boolean checkSpecialClasses(Object obj) throws IOException {
  310.  
  311.     /*
  312.      * If this is a class, don't allow substitution
  313.      */
  314.     if (obj instanceof Class) {
  315.         outputClass((Class)obj);
  316.         return true;
  317.     }
  318.  
  319.     if (obj instanceof ObjectStreamClass) {
  320.         outputClassDescriptor((ObjectStreamClass)obj);
  321.         return true;
  322.     }
  323.  
  324.     return false;
  325.     }
  326.  
  327.     /*
  328.      * Check for special cases of substitutable serializing objects.
  329.      * These classes are replaceable.
  330.      */
  331.     private boolean checkSubstitutableSpecialClasses(Object obj)
  332.     throws IOException
  333.     {
  334.     if (obj instanceof String) {
  335.         outputString((String)obj);
  336.         return true;
  337.     }
  338.  
  339.     if (obj.getClass().isArray()) {
  340.         outputArray(obj);
  341.         return true;
  342.     }
  343.  
  344.     return false;
  345.     }
  346.  
  347.     /**
  348.      * Write the non-static and non-transient fields of the current class
  349.      * to this stream.  This may only be called from the writeObject method
  350.      * of the class being serialized. It will throw the NotActiveException
  351.      * if it is called otherwise.
  352.      * @since     JDK1.1
  353.      */
  354.     public final void defaultWriteObject() throws IOException {
  355.      
  356.     /*
  357.      * RMI over IIOP hook. Invoke delegate method if indicated.
  358.      */
  359.     if (isTrustedSubclass) {
  360.         ((ObjectOutputStreamDelegate) this).defaultWriteObjectDelegate();
  361.         return;
  362.     }
  363.          
  364.     if (currentObject == null || currentClassDesc == null)
  365.         throw new NotActiveException("defaultWriteObject");
  366.     
  367.     if (currentClassDesc.getFieldSequence() != null) {
  368.         boolean prevmode = setBlockData(false);
  369.         outputClassFields(currentObject, currentClassDesc.forClass(),
  370.                   currentClassDesc.getFieldSequence());
  371.         setBlockData(prevmode);
  372.     }
  373.     }
  374.     
  375.     /**
  376.      * Reset will disregard the state of any objects already written
  377.      * to the stream.  The state is reset to be the same as a new
  378.      * ObjectOutputStream.  The current point in the stream is marked
  379.      * as reset so the corresponding ObjectInputStream will be reset
  380.      * at the same point.  Objects previously written to the stream
  381.      * will not be refered to as already being in the stream.  They
  382.      * will be written to the stream again.
  383.      * @since     JDK1.1
  384.      */
  385.     public void reset() throws IOException {
  386.     if (currentObject != null || currentClassDesc != null)
  387.         throw new IOException("Illegal call to reset");
  388.     
  389.     /* Write a reset to the stream. */        
  390.     setBlockData(false);
  391.     writeCode(TC_RESET);
  392.     
  393.     resetStream();            // re-init the stream
  394.     abortIOException = null;
  395.     }
  396.  
  397.     /*
  398.      * Internal reset function to reinitialize the state of the stream.
  399.      * Reset state of things changed by using the stream.
  400.      */
  401.     private void resetStream() throws IOException {
  402.     if (wireHandle2Object == null) {
  403.         wireHandle2Object = new Object[100];
  404.         wireNextHandle = new int[100];
  405.         wireHash2Handle = new int[101];
  406.     } else {
  407.  
  408.         // Storage Optimization for frequent calls to reset method.
  409.         // Do not reallocate, only reinitialize.
  410.         for (int i = 0; i < nextWireOffset; i++) {
  411.         wireHandle2Object[i] = null;
  412.         wireNextHandle[i] = 0;
  413.         }
  414.     }
  415.       nextWireOffset = 0;
  416.       for (int i = 0; i < wireHash2Handle.length; i++) {
  417.           wireHash2Handle[i] = -1;
  418.       }
  419.     if (classDescStack == null)
  420.         classDescStack = new Stack();
  421.     else
  422.         classDescStack.setSize(0);
  423.     
  424.     for (int i = 0; i < nextReplaceOffset; i++)
  425.         replaceObjects[i] = null;
  426.     nextReplaceOffset = 0;
  427.     setBlockData(true);        /* Re-enable buffering */
  428.     }
  429.     
  430.     /**
  431.      * Subclasses may implement this method to allow class data to be stored
  432.      * in the stream. By default this method does nothing.
  433.      * The corresponding method in ObjectInputStream is resolveClass.
  434.      * This method is called exactly once for each unique class in the stream.
  435.      * The class name and signature will have already been written to the stream.
  436.      * This method may make free use of the ObjectOutputStream to save
  437.      * any representation of the class it deems suitable (for example,
  438.      * the bytes of the class file).  The resolveClass method in the corresponding
  439.      * subclass of ObjectInputStream must read and use any data or objects
  440.      * written by annotateClass. 
  441.      * annotateClass is called only for normal classes.  Arrays are not normal classes.
  442.      * @exception IOException Any exception thrown by the underlying OutputStream.
  443.      * @since     JDK1.1
  444.      */
  445.     protected void annotateClass(Class cl)
  446.     throws IOException
  447.     {
  448.     }
  449.  
  450.     /** This method will allow trusted subclasses of ObjectOutputStream
  451.      * to substitute one object for another during
  452.      * serialization. Replacing objects is disabled until
  453.      * enableReplaceObject is called. The enableReplaceObject method
  454.      * checks that the stream requesting to do replacment can be
  455.      * trusted. Every reference to serializable objects is passed to
  456.      * replaceObject.  To insure that the private state of objects is
  457.      * not unintentionally exposed only trusted streams may use
  458.      * replaceObject. <p>
  459.      *
  460.      * When a subclass is replacing objects it must insure that either
  461.      * a complementary substitution must be made during
  462.      * deserialization or that the substituted object is compatible
  463.      * with every field where the reference will be stored.  Objects
  464.      * whose type is not a subclass of the type of the field or array
  465.      * element abort the serialization by raising an exception and the
  466.      * object is not be stored. <p>
  467.      *
  468.      * This method is called only once when each object is first encountered.
  469.      * All subsequent references to the object will be redirected to the
  470.      * new object. This method should return the object to be substituted or
  471.      * the original object. <P>
  472.      *
  473.      * Null can be returned as the object to be substituted, but may
  474.      * cause NullReferenceException in classes that contain references
  475.      * to the original object since they may be expecting an object
  476.      * instead of null.<p>
  477.      *
  478.      * @exception IOException Any exception thrown by the underlying
  479.      * OutputStream.
  480.      * @since     JDK1.1
  481.      */
  482.     protected Object replaceObject(Object obj)
  483.     throws IOException
  484.     {
  485.     return obj;
  486.     }
  487.  
  488.     /**
  489.      * Enable the stream to do replacement of objects in the stream.
  490.      * If the stream is a trusted class it is allowed to enable replacement.
  491.      * Trusted classes are those classes with a classLoader equals null. <p>
  492.      * 
  493.      * When enabled the replaceObject method is called for every object
  494.      * being serialized.
  495.      * 
  496.      * @exception SecurityException The classloader of this stream object is non-null.
  497.      * @since     JDK1.1
  498.      */
  499.     protected final boolean enableReplaceObject(boolean enable)
  500.     throws SecurityException
  501.     {
  502.      
  503.     /*
  504.      * RMI over IIOP hook. Invoke delegate method if indicated.
  505.      */
  506.     if (isTrustedSubclass) {
  507.       return ((ObjectOutputStreamDelegate) this).enableReplaceObjectDelegate(enable);
  508.     }
  509.          
  510.     boolean previous = enableReplace;
  511.     if (enable) {
  512.         ClassLoader loader = this.getClass().getClassLoader();
  513.         if (loader == null) {
  514.         enableReplace = true;
  515.         return previous;
  516.         }
  517.         throw new SecurityException("Not trusted class");
  518.     } else {
  519.         enableReplace = false;
  520.     }
  521.     return previous;
  522.     }
  523.  
  524.     /**
  525.      * The writeStreamHeader method is provided so subclasses can
  526.      * append or prepend their own header to the stream.
  527.      * It writes the magic number and version to the stream.
  528.      * @since     JDK1.1
  529.      */
  530.     protected void writeStreamHeader() throws IOException {
  531.     writeShort(STREAM_MAGIC);
  532.     writeShort(STREAM_VERSION);
  533.     }
  534.  
  535.     /**
  536.      * Write a string to the stream.
  537.      * Note that since Strings are Objects, writeObject
  538.      * will behave identically.
  539.      */
  540.     private void outputString(String s) throws IOException {
  541.     /* Allocate a write handle but don't write it to the stream,
  542.      * Write out the code for a string,
  543.      * the read can regenerate the same sequence and it saves bytes.
  544.      */
  545.     assignWireOffset(s);
  546.     writeCode(TC_STRING);
  547.     writeUTF(s); 
  548.     }
  549.  
  550.  
  551.     /* Classes are special, they can not created during deserialization,
  552.      * but the appropriate class can be found. 
  553.      */
  554.     private void outputClass(Class aclass) throws IOException {
  555.  
  556.     writeCode(TC_CLASS);
  557.     /* Find the class descriptor and write it out */
  558.     ObjectStreamClass v = ObjectStreamClass.lookup(aclass);
  559.  
  560.     if (v == null)
  561.         throw new NotSerializableException(aclass.getName());
  562.  
  563.     outputClassDescriptor(v);
  564.  
  565.     assignWireOffset(aclass);
  566.     }
  567.   
  568.  
  569.     /* Write the class descriptor */
  570.     private void outputClassDescriptor(ObjectStreamClass classdesc) 
  571.     throws IOException
  572.     {
  573.     if (serializeNullAndRepeat(classdesc))
  574.         return;
  575.  
  576.     /* Write out the code for a class
  577.      * Write out the class name and its serialVersionUID
  578.      */
  579.     writeCode(TC_CLASSDESC);
  580.     String classname = classdesc.getName();
  581.  
  582.     writeUTF(classname);
  583.     writeLong(classdesc.getSerialVersionUID());
  584.  
  585.     /* This is done here to be symetric with the inputClass method
  586.      * Since the resolveClassName() method may use the stream.
  587.      * The assignments of wirehandles must be done in the same order
  588.      */
  589.     assignWireOffset(classdesc);
  590.  
  591.     /* Write the version description for this class */
  592.     classdesc.write(this);
  593.  
  594.     /* Give subclassers a chance to add the class implementation
  595.      * to the stream.  Set BlockData mode so any information they
  596.      * write can be skipped on reading.
  597.      */
  598.     boolean prevMode = setBlockData(true);
  599.     annotateClass(classdesc.forClass());
  600.     setBlockData(prevMode);
  601.     writeCode(TC_ENDBLOCKDATA);
  602.  
  603.     /*
  604.      * Write out the superclass descriptor of this descriptor
  605.      * only if it is for a java.io.Serializable class.
  606.      * else write null.
  607.      */
  608.     ObjectStreamClass superdesc = classdesc.getSuperclass();
  609.     outputClassDescriptor(superdesc);
  610.     }
  611.     
  612.     /**
  613.      * Write an array out. Note that since Arrays are Objects, writeObject(obj)
  614.      * will behave identically. <br><br>
  615.      * @param o can represent an array of any type/dimension.
  616.      */
  617.     private void outputArray(Object obj)
  618.     throws IOException
  619.     {
  620.     Class currclass = obj.getClass();
  621.  
  622.     ObjectStreamClass v = ObjectStreamClass.lookup(currclass);
  623.  
  624.     /* Write out the code for an array and the name of the class */
  625.     writeCode(TC_ARRAY);
  626.     outputClassDescriptor(v);
  627.  
  628.     /* Assign the wirehandle for this object and outputArrayValues
  629.      * writes the length and the array contents.
  630.      */
  631.     assignWireOffset(obj);
  632.  
  633.     int i, length;
  634.     Class type = currclass.getComponentType();
  635.  
  636.     if (type.isPrimitive()) {
  637.         /* Write arrays of primitive types using the DataOutput
  638.          * methods that convert each element into the output buffer.
  639.          * The data types are ordered by the frequency
  640.          * in which they are expected to occur.
  641.          */
  642.         if (type == Integer.TYPE) {
  643.         int[] array = (int[])obj;
  644.         length = array.length;
  645.         writeInt(length);
  646.         for (i = 0; i < length; i++) {
  647.             writeInt(array[i]);
  648.         }
  649.         } else if (type == Byte.TYPE) {
  650.         byte[] array = (byte[])obj;
  651.         length = array.length;
  652.         writeInt(length);
  653.         writeInternal(array, 0, length, true);
  654.         } else if (type == Long.TYPE) {
  655.         long[] array = (long[])obj;
  656.         length = array.length;
  657.         writeInt(length);
  658.         for (i = 0; i < length; i++) {
  659.             writeLong(array[i]);
  660.         }
  661.         } else if (type == Float.TYPE) {
  662.         float[] array = (float[])obj;
  663.         length = array.length;
  664.         writeInt(length);
  665.         for (i = 0; i < length; i++) {
  666.             writeFloat(array[i]);
  667.         }
  668.         } else if (type == Double.TYPE) {
  669.         double[] array = (double[])obj;
  670.         length = array.length;
  671.         writeInt(length);
  672.         for (i = 0; i < length; i++) {
  673.             writeDouble(array[i]);
  674.         }
  675.         } else if (type == Short.TYPE) {
  676.         short[] array = (short[])obj;
  677.         length = array.length;
  678.         writeInt(length);
  679.         for (i = 0; i < length; i++) {
  680.             writeShort(array[i]);
  681.         }
  682.         } else if (type == Character.TYPE) {
  683.         char[] array = (char[])obj;
  684.         length = array.length;
  685.         writeInt(length);
  686.         for (i = 0; i < length; i++) {
  687.             writeChar(array[i]);
  688.         }
  689.         } else if (type == Boolean.TYPE) {
  690.         boolean[] array = (boolean[])obj;
  691.         length = array.length;
  692.         writeInt(length);
  693.         for (i = 0; i < length; i++) {
  694.             writeBoolean(array[i]);
  695.         }
  696.         } else {
  697.         throw new InvalidClassException(currclass.getName());
  698.         }
  699.     } else {
  700.         Object[] array = (Object[])obj;
  701.         length = array.length;
  702.         writeInt(length);
  703.         for (i = 0; i < length; i++) {
  704.         writeObject(array[i]);
  705.         }
  706.     }
  707.     }
  708.  
  709.     /*
  710.      * Put the object into the stream The newObject code is written
  711.      * followed by the ObjectStreamClass for the object's class.  Each
  712.      * of the objects classes is written using the default
  713.      * serialization code and dispatching to Specials where
  714.      * appropriate.
  715.      */
  716.     private void outputObject(Object obj)
  717.     throws IOException
  718.     {
  719.     currentObject = obj;
  720.     Class currclass = obj.getClass();
  721.  
  722.     /* Get the Class descriptor for this class,
  723.      * Throw a NotSerializableException if there is none.
  724.      */
  725.     currentClassDesc = ObjectStreamClass.lookup(currclass);
  726.     if (currentClassDesc == null) {
  727.         throw new NotSerializableException(currclass.getName());
  728.     }
  729.  
  730.     /* Write the code to expect an instance and
  731.      * the class descriptor of the instance
  732.      */
  733.     writeCode(TC_OBJECT);
  734.     outputClassDescriptor(currentClassDesc);
  735.  
  736.     /* Assign the next wirehandle */
  737.     assignWireOffset(obj);
  738.  
  739.     /* If the object is externalizable,
  740.      * call writeExternal.
  741.      * else do Serializable processing.
  742.      */
  743.     if (currentClassDesc.isExternalizable()) {
  744.         Externalizable ext = (Externalizable)obj;
  745.         ext.writeExternal(this);
  746.     } else {
  747.  
  748.         /* The object's classes should be processed from supertype to subtype
  749.          * Push all the clases of the current object onto a stack.
  750.          * Remember the stack pointer where this set of classes is being pushed.
  751.          */
  752.         int stackMark = classDescStack.size();
  753.         try {
  754.         ObjectStreamClass next;
  755.         while ((next = currentClassDesc.getSuperclass()) != null) {
  756.             classDescStack.push(currentClassDesc);
  757.             currentClassDesc = next;
  758.         }
  759.  
  760.         /* 
  761.          * For currentClassDesc and all the pushed class descriptors
  762.          *    If the class is writing its own data
  763.          *          set blockData = true; call the class writeObject method
  764.          *    If not
  765.          *     invoke either the defaultWriteObject method.
  766.          */
  767.         do {
  768.             if (currentClassDesc.hasWriteObject()) {
  769.             setBlockData(true); /* Block any data the class writes */
  770.             invokeObjectWriter(obj, currentClassDesc.forClass());
  771.             setBlockData(false);
  772.             writeCode(TC_ENDBLOCKDATA);
  773.             } else {
  774.             defaultWriteObject();
  775.             }
  776.         } while (classDescStack.size() > stackMark &&
  777.              (currentClassDesc = (ObjectStreamClass)classDescStack.pop()) != null);
  778.         } finally {
  779.         classDescStack.setSize(stackMark);
  780.         }
  781.     }
  782.     }
  783.     
  784.     /* Serialize the reference if it is NULL or is for an object that
  785.      * was already replaced or already serialized.
  786.      * If the object was already replaced, look for the replacement
  787.      * object in the known objects and if found, write its handle
  788.      * Return True if the reference is either null or a repeat.
  789.      */
  790.     private boolean serializeNullAndRepeat(Object obj)
  791.     throws IOException
  792.     {
  793.         if (obj == null) {
  794.         writeCode(TC_NULL);
  795.         return true;
  796.     }
  797.     /* Look to see if this object has already been replaced.
  798.      * If so, proceed using the replacement object.
  799.      */
  800.     if (replaceObjects != null) {
  801.         for (int i = 0; i < nextReplaceOffset; i+= 2) {
  802.         if (replaceObjects[i] == obj) {
  803.             obj = replaceObjects[i+1];
  804.             break;
  805.         }
  806.         }
  807.     }
  808.  
  809.     int handle = findWireOffset(obj);
  810.     if (handle >= 0) {
  811.         /* Add a reference to the stream */
  812.         writeCode(TC_REFERENCE);
  813.         writeInt(handle + baseWireHandle);
  814.         return true;
  815.     }
  816.     return false;        // not serialized, its up to the caller
  817.     }
  818.  
  819.     /*
  820.      * Locate and return if found the handle for the specified object.
  821.      * -1 is returned if the object does not occur in the array of
  822.      * known objects. 
  823.      */
  824.     private int findWireOffset(Object obj) {
  825.     int hash = System.identityHashCode(obj);
  826.     int index = (hash & 0x7FFFFFFF) % wireHash2Handle.length;
  827.  
  828.     for (int handle = wireHash2Handle[index];
  829.          handle >= 0;
  830.          handle = wireNextHandle[handle]) {
  831.         
  832.         if (wireHandle2Object[handle] == obj)
  833.         return handle;
  834.     }
  835.     return -1;
  836.     }
  837.  
  838.     /* Allocate a handle for an object.
  839.      * The Vector is indexed by the wireHandleOffset
  840.      * and contains the object.
  841.      */
  842.     private void assignWireOffset(Object obj)
  843.     throws IOException
  844.     {
  845.     // Extend the array if there isn't room for this new element
  846.     if (nextWireOffset == wireHandle2Object.length) {
  847.         Object[] oldhandles = wireHandle2Object;
  848.         wireHandle2Object = new Object[nextWireOffset*2];
  849.         System.arraycopy(oldhandles, 0,
  850.                  wireHandle2Object, 0,
  851.                  nextWireOffset);
  852.         int[] oldnexthandles = wireNextHandle;
  853.         wireNextHandle = new int[nextWireOffset*2];
  854.         System.arraycopy(oldnexthandles, 0,
  855.                  wireNextHandle, 0,
  856.                  nextWireOffset);
  857.         // TBD: Rehash the hash array if necessary
  858.     }
  859.     wireHandle2Object[nextWireOffset] = obj;
  860.  
  861.     hashInsert(obj, nextWireOffset);
  862.  
  863.     nextWireOffset++;
  864.     return;
  865.     }
  866.  
  867.  
  868.     /*
  869.      * Insert the specified object into the hash array and link if
  870.      * necessary. Put the new object into the hash table and link the
  871.      * previous to it. Newer objects occur earlier in the list.
  872.      */
  873.     private void hashInsert(Object obj, int offset) {
  874.     int hash = System.identityHashCode(obj);
  875.     int index = (hash & 0x7FFFFFFF) % wireHash2Handle.length;
  876.     wireNextHandle[offset] = wireHash2Handle[index];
  877.     wireHash2Handle[index] = offset;
  878.     }
  879.  
  880.     /*
  881.      * Add a replacement object to the table.
  882.      * The even numbered indices are the original objects.
  883.      * The odd numbered indices are the replacement objects.
  884.      *
  885.      */
  886.     private void addReplacement(Object orig, Object replacement) {
  887.     // Extend the array if there isn't room for this new element
  888.  
  889.     if (replaceObjects == null) {
  890.         replaceObjects = new Object[10];
  891.     }
  892.     if (nextReplaceOffset == replaceObjects.length) {
  893.         Object[] oldhandles = replaceObjects;
  894.         replaceObjects = new Object[2+nextReplaceOffset*2];
  895.         System.arraycopy(oldhandles, 0,
  896.                  replaceObjects, 0,
  897.                  nextReplaceOffset);
  898.     }
  899.     replaceObjects[nextReplaceOffset++] = orig;
  900.     replaceObjects[nextReplaceOffset++] = replacement;
  901.     }
  902.  
  903.     /* Write out the code indicating the type what follows.
  904.      * See ObjectStreamConstants for definitions.
  905.      */
  906.     private void writeCode(int tag)
  907.     throws IOException
  908.     {
  909.     writeByte(tag);
  910.     }
  911.  
  912.     /*
  913.      * Implement the OutputStream methods.  The stream has
  914.      * two modes used internally to ObjectOutputStream.  When
  915.      * in BlockData mode, all writes are buffered and written
  916.      * to the underlying stream prefixed by a code and length.
  917.      * When not in BlockData mode (false), writes pass directly
  918.      * through to the underlying stream.
  919.      * The BlockData mode is used to encapsulate data written
  920.      * by class specific writeObject methods that is intended
  921.      * only to be read by corresponding readObject method of the 
  922.      * same class.  The blocking of data allows it to be skipped
  923.      * if necessary.
  924.      *
  925.      * The setBlockData method is used to switch buffering
  926.      * on and off.  When switching between on and off
  927.      * the buffer is drained.
  928.      *
  929.      * The actual buffering is very similar to that of
  930.      * BufferedOutputStream but BufferedOutputStream can
  931.      * write to the underlying stream without the headers.
  932.      */
  933.     private boolean blockDataMode;    /* true to buffer and block data */
  934.     private byte[] buf;        /* byte array of buffered data. */
  935.     private int count;        /* count of bytes in the buffer */
  936.     private OutputStream out;    /* Stream to write the data to */
  937.  
  938.     /**
  939.      * Writes a byte. This method will block until the byte is actually
  940.      * written.
  941.      * @param b    the byte
  942.      * @exception IOException If an I/O error has occurred.
  943.      * @since     JDK1.1
  944.      */
  945.     public void write(int data) throws IOException {
  946.     
  947.     if (count >= buf.length)
  948.         drain();        /* Drain, make room for more */
  949.     buf[count++] = (byte)data;
  950.     }
  951.  
  952.     /**
  953.      * Writes an array of bytes. This method will block until the bytes
  954.      * are actually written.
  955.      * @param b    the data to be written
  956.      * @exception IOException If an I/O error has occurred.
  957.      * @since     JDK1.1
  958.      */
  959.     public void write(byte b[]) throws IOException {
  960.     write(b, 0, b.length);
  961.     }
  962.  
  963.     /*
  964.      * Writes a sub array of bytes. 
  965.      * @param b    the data to be written
  966.      * @param off    the start offset in the data
  967.      * @param len    the number of bytes that are written
  968.      * @param copyOnWrite do not expose b to overrides of ObjectStream.write,
  969.      *                    copy the contents of b to a buffer before writing.
  970.      * @exception IOException If an I/O error has occurred.
  971.      * @since     JDK1.1
  972.      */
  973.     private void writeInternal(byte b[], int off, int len, 
  974.                    boolean copyOnWrite) throws IOException {
  975.     if (len < 0)
  976.         throw new IndexOutOfBoundsException();
  977.  
  978.     /*
  979.      * If array will fit in output buffer, copy it in there; otherwise,
  980.      * drain anything in the buffer and send it through to underlying
  981.      * output stream directly.
  982.      */
  983.     int avail = buf.length - count;
  984.     if (len <= avail) {
  985.         System.arraycopy(b, off, buf, count, len);
  986.         count += len;
  987.     } else if (! blockDataMode && copyOnWrite) {
  988.         bufferedWrite(b, off, len);    
  989.     } else {
  990.         drain();
  991.         if (blockDataMode) {
  992.         if (len <= 255) {
  993.             out.write(TC_BLOCKDATA);
  994.             out.write(len);
  995.         } else {
  996.             // use block data with int size if necessary
  997.             out.write(TC_BLOCKDATALONG);
  998.             // send 32 bit int directly to underlying stream
  999.             out.write((len >> 24) & 0xFF);
  1000.             out.write((len >> 16) & 0xFF);
  1001.             out.write((len >>  8) & 0xFF);
  1002.             out.write(len & 0xFF);
  1003.         }
  1004.         }
  1005.         out.write(b, off, len);
  1006.     }
  1007.     }
  1008.  
  1009.  
  1010.     /**
  1011.      * Flushes the stream. This will write any buffered
  1012.      * output bytes and flush through to the underlying stream.
  1013.      * @exception IOException If an I/O error has occurred.
  1014.      * @since     JDK1.1
  1015.      */
  1016.     public void flush() throws IOException {
  1017.     drain();
  1018.     out.flush();
  1019.     }
  1020.  
  1021.     /**
  1022.      * Drain any buffered data in ObjectOutputStream.  Similar to flush
  1023.      * but does not propagate the flush to the underlaying stream.
  1024.      * @since     JDK1.1
  1025.      */
  1026.     protected void drain() throws IOException {
  1027.     /*
  1028.      * Drain the data buffer.
  1029.      * If the blocking mode is on, prepend the buffer
  1030.      * with the code for a blocked data and the length.
  1031.      * The code is TC_BLOCKDATA and the length is < 255 so it fits
  1032.      * in a byte. 
  1033.      */
  1034.     if (count == 0)
  1035.         return;
  1036.  
  1037.     /* If in blockdata mode, write the header with the count.
  1038.      * If the count is < 256, use the short header form.
  1039.      * othewise use the long form.
  1040.      */
  1041.     if (blockDataMode) {
  1042.         if (count <= 255) {
  1043.         out.write(TC_BLOCKDATA);
  1044.         out.write(count);
  1045.         } else {
  1046.         out.write(TC_BLOCKDATALONG);
  1047.         out.write((count >> 24) & 0xFF);
  1048.         out.write((count >> 16) & 0xFF);
  1049.         out.write((count >>  8) & 0xFF);
  1050.         out.write(count & 0xFF);
  1051.         }
  1052.     }
  1053.     out.write(buf, 0, count);
  1054.     count = 0;
  1055.     }
  1056.  
  1057.     /**
  1058.      * Closes the stream. This method must be called
  1059.      * to release any resources associated with the
  1060.      * stream.
  1061.      * @exception IOException If an I/O error has occurred.
  1062.      * @since     JDK1.1
  1063.      */
  1064.     public void close() throws IOException {
  1065.     flush();        /* Make sure we're not holding any data */
  1066.     out.close();
  1067.     }
  1068.  
  1069.     /*
  1070.      * Set the blockData mode,  if it turned from on to off
  1071.      * the buffer is drained.  The previous mode is returned.
  1072.      */
  1073.     private boolean setBlockData(boolean mode) throws IOException {
  1074.     if (blockDataMode == mode)
  1075.         return mode;
  1076.     drain();
  1077.     blockDataMode = mode;
  1078.     return !mode;        /* previous value was the opposite */
  1079.     }
  1080.     
  1081.     /* -------------------------------------------------------------- */
  1082.     /*
  1083.      * Provide the methods to implement DataOutput.
  1084.      * These are copied from DataOutputStream to avoid the overhead
  1085.      * of multiple method calls and to buffer the data directly.
  1086.      */
  1087.     private DataOutputStream dos;
  1088.  
  1089.     /**
  1090.      * Writes a boolean.
  1091.      * @param data the boolean to be written
  1092.      * @since     JDK1.1
  1093.      */
  1094.     public void writeBoolean(boolean data) throws IOException {
  1095.     if (count >= buf.length)
  1096.         drain();
  1097.     buf[count++] = (byte)(data ? 1 : 0);
  1098.  
  1099.     }
  1100.  
  1101.     /**
  1102.      * Writes a sub array of bytes. 
  1103.      * @param b    the data to be written
  1104.      * @param off    the start offset in the data
  1105.      * @param len    the number of bytes that are written
  1106.      * @exception IOException If an I/O error has occurred.
  1107.      * @since     JDK1.1
  1108.      */
  1109.     public void write(byte b[], int off, int len) throws IOException {
  1110.     writeInternal(b, off, len, false);
  1111.     }
  1112.  
  1113.     /* Use write buffering of byte[] b to prevent exposure of
  1114.      * 'b' reference to untrusted overrides of ObjectOutput.write(byte[]).
  1115.      * 
  1116.      * NOTE: Method is only intended for protecting serializable byte []
  1117.      *       fields written by default serialization. Thus, it can 
  1118.      *       never get called while in blockDataMode.
  1119.      */
  1120.     private void bufferedWrite(byte b[], int off, int len) throws IOException {
  1121.     int bufAvail = buf.length - count;
  1122.     int bytesToWrite = len;
  1123.     
  1124.     // Handle case where byte array is larger than available buffer.
  1125.     if (bytesToWrite > bufAvail) {
  1126.  
  1127.         // Logically: fill rest of 'buf' with 'b' and drain.
  1128.         System.arraycopy(b, off, buf, count, bufAvail);
  1129.         off += bufAvail;
  1130.         bytesToWrite -= bufAvail;
  1131.         out.write(buf, 0, buf.length);
  1132.         count = 0;
  1133.  
  1134.         // Write out buf.length chunks of byte array.
  1135.         while (bytesToWrite >= buf.length) {
  1136.         System.arraycopy(b, off, buf, 0, buf.length);
  1137.         out.write(buf, 0, buf.length);
  1138.         off += buf.length;
  1139.         bytesToWrite -= buf.length;
  1140.  
  1141.         // Optimization: do not modify or access "count" in this loop.
  1142.         }
  1143.     }
  1144.  
  1145.     // Put remainder of byte array b into buffer. 
  1146.     if (bytesToWrite != 0) {
  1147.         System.arraycopy(b, off, buf, count, bytesToWrite);
  1148.         count += bytesToWrite;
  1149.     }
  1150.     }
  1151.  
  1152.     /**
  1153.      * Writes an 8 bit byte.
  1154.      * @param data the byte value to be written
  1155.      * @since     JDK1.1
  1156.      */
  1157.     public void writeByte(int data) throws IOException  {
  1158.     if (count >= buf.length)
  1159.         drain();
  1160.     buf[count++] = (byte)data;
  1161.     }
  1162.  
  1163.     /**
  1164.      * Writes a 16 bit short.
  1165.      * @param data the short value to be written
  1166.      * @since     JDK1.1
  1167.      */
  1168.     public void writeShort(int data)  throws IOException {
  1169.     if (count + 2 > buf.length)
  1170.         drain();
  1171.     buf[count++] = (byte)((data >>>  8));
  1172.     buf[count++] = (byte)((data >>>  0));
  1173.     }
  1174.  
  1175.     /**
  1176.      * Writes a 16 bit char.
  1177.      * @param data the char value to be written
  1178.      * @since     JDK1.1
  1179.      */
  1180.     public void writeChar(int data)  throws IOException {
  1181.     if (count + 2 > buf.length)
  1182.         drain();
  1183.     buf[count++] = (byte)((data >>>  8));
  1184.     buf[count++] = (byte)((data >>>  0));
  1185.     }
  1186.  
  1187.     /**
  1188.      * Writes a 32 bit int.
  1189.      * @param data the integer value to be written
  1190.      * @since     JDK1.1
  1191.      */
  1192.     public void writeInt(int data)  throws IOException {
  1193.     if (count + 4 > buf.length)
  1194.         drain();
  1195.     buf[count++] = (byte)((data >>> 24));
  1196.     buf[count++] = (byte)((data >>> 16));
  1197.     buf[count++] = (byte)((data >>>  8));
  1198.     buf[count++] = (byte)((data >>>  0));
  1199.     }
  1200.  
  1201.     /**
  1202.      * Writes a 64 bit long.
  1203.      * @param data the long value to be written
  1204.      * @since     JDK1.1
  1205.      */
  1206.     public void writeLong(long data)  throws IOException {
  1207.     if (count + 8 > buf.length)
  1208.         drain();
  1209.     buf[count++] = (byte)((int)(data >>> 56));
  1210.     buf[count++] = (byte)((int)(data >>> 48));
  1211.     buf[count++] = (byte)((int)(data >>> 40));
  1212.     buf[count++] = (byte)((int)(data >>> 32));
  1213.     buf[count++] = (byte)((data >>> 24));
  1214.     buf[count++] = (byte)((data >>> 16));
  1215.     buf[count++] = (byte)((data >>>  8));
  1216.     buf[count++] = (byte)((data >>>  0));
  1217.     }
  1218.  
  1219.     /**
  1220.      * Writes a 32 bit float.
  1221.      * @param data the float value to be written
  1222.      * @since     JDK1.1
  1223.      */
  1224.     public void writeFloat(float data) throws IOException {
  1225.     int value = Float.floatToIntBits(data);
  1226.     if (count + 4 > buf.length)
  1227.         drain();
  1228.     buf[count++] = (byte)((value >>> 24));
  1229.     buf[count++] = (byte)((value >>> 16));
  1230.     buf[count++] = (byte)((value >>>  8));
  1231.     buf[count++] = (byte)((value >>>  0));
  1232.     }
  1233.  
  1234.     /**
  1235.      * Writes a 64 bit double.
  1236.      * @param data the double value to be written
  1237.      * @since     JDK1.1
  1238.      */
  1239.     public void writeDouble(double data) throws IOException {
  1240.     long value = Double.doubleToLongBits(data);
  1241.     if (count + 8 > buf.length)
  1242.         drain();
  1243.     buf[count++] = (byte)((int)(value >>> 56));
  1244.     buf[count++] = (byte)((int)(value >>> 48));
  1245.     buf[count++] = (byte)((int)(value >>> 40));
  1246.     buf[count++] = (byte)((int)(value >>> 32));
  1247.     buf[count++] = (byte)((value >>> 24));
  1248.     buf[count++] = (byte)((value >>> 16));
  1249.     buf[count++] = (byte)((value >>>  8));
  1250.     buf[count++] = (byte)((value >>>  0));
  1251.     }
  1252.  
  1253.     /**
  1254.      * Writes a String as a sequence of bytes.
  1255.      * @param s the String of bytes to be written
  1256.      * @since     JDK1.1
  1257.      */
  1258.     public void writeBytes(String data) throws IOException {
  1259.     dos.writeBytes(data);
  1260.     }
  1261.  
  1262.     /**
  1263.      * Writes a String as a sequence of chars.
  1264.      * @param s the String of chars to be written
  1265.      * @since     JDK1.1
  1266.      */
  1267.     public void writeChars(String data) throws IOException {
  1268.     dos.writeChars(data);
  1269.     }
  1270.  
  1271.     /**
  1272.      * Writes a String in UTF format.
  1273.      * @param str the String in UTF format
  1274.      * @since     JDK1.1
  1275.      */
  1276.     public void writeUTF(String data) throws IOException {
  1277.     dos.writeUTF(data);
  1278.     }
  1279.     
  1280.     /*************************************************************/
  1281.     
  1282.     /* Remember the first exception that stopped this stream. */
  1283.     private IOException abortIOException = null;
  1284.     
  1285.     /* Write the fields of the specified class.
  1286.      * The native implemention sorts the field names to put them
  1287.      * in cononical order, ignores transient and static fields
  1288.      * and invokes the appropriate write* method on this class.
  1289.      */
  1290.     private native void outputClassFields(Object o, Class cl,
  1291.                       int[] fieldSequence)
  1292.     throws IOException, InvalidClassException;
  1293.  
  1294.     /* Test if Read/WriteObject methods are present, if so
  1295.      * invoke writer and return true.
  1296.      */
  1297.     private native boolean invokeObjectWriter(Object o, Class c)
  1298.     throws IOException;
  1299.  
  1300.     /* Object references are mapped to the wire handles through a hashtable
  1301.      * WireHandles are integers generated by the ObjectOutputStream,
  1302.      * they need only be unique within a stream.
  1303.      * Objects are assigned sequential handles and stored in wireHandle2Object.
  1304.      * The handle for an object is its index in wireHandle2Object.
  1305.      * Object with the "same" hashcode are chained using wireHash2Handle.
  1306.      * The hashcode of objects is used to index through the wireHash2Handle.
  1307.      * -1 is the marker for unused cells in wireNextHandle
  1308.      */
  1309.     private Object[] wireHandle2Object;
  1310.     private int[] wireNextHandle;
  1311.     private int[] wireHash2Handle;
  1312.     private int nextWireOffset;
  1313.  
  1314.     /* The object is the current object and ClassDescriptor is the current
  1315.      * subclass of the object being read. Nesting information is kept
  1316.      * on the stack.
  1317.      */
  1318.     private Object currentObject;
  1319.     private ObjectStreamClass currentClassDesc;
  1320.     private Stack classDescStack;
  1321.  
  1322.     /* 
  1323.      * Flag set to true to allow replaceObject to be called.
  1324.      * Set by enableReplaceObject.
  1325.      * The array of replaceObjects and the index of the next insertion.
  1326.      */
  1327.     boolean enableReplace;
  1328.     private Object[] replaceObjects;
  1329.     private int nextReplaceOffset;
  1330.  
  1331.     /* Recursion level, starts at zero and is incremented for each entry
  1332.      * to writeObject.  Decremented before exit.
  1333.      */ 
  1334.     private int recursionDepth = 0;
  1335.     
  1336.     /*
  1337.      * RMI over IIOP hook: Flag to indicate if we are
  1338.      * a trusted subclass that has implemented the delegate
  1339.      * interface "sun.io.ObjectOutputStreamDelegate".
  1340.      */
  1341.     private boolean isTrustedSubclass = false;
  1342. }
  1343.